/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

/* Hybrid linear-contour model reconstruction */
#include "precomp.hpp"

#define CV_IMPL CV_EXTERN_C

const float LCM_CONST_ZERO = 1e-6f;

/****************************************************************************************\
*                                    Auxiliary struct definitions                                 *
\****************************************************************************************/
typedef struct CvLCM {
	CvGraph* Graph;
	CvVoronoiDiagram2D* VoronoiDiagram;
	CvMemStorage* ContourStorage;
	CvMemStorage* EdgeStorage;
	float maxWidth;
} CvLCM;

typedef struct CvLCMComplexNodeData {
	CvVoronoiNode2D edge_node;
	CvPoint2D32f site_first_pt;
	CvPoint2D32f site_last_pt;
	CvVoronoiSite2D* site_first;
	CvVoronoiSite2D* site_last;
	CvVoronoiEdge2D* edge;
} CvLCMComplexNodeData;

typedef struct CvLCMData {
	CvVoronoiNode2D* pnode;
	CvVoronoiSite2D* psite;
	CvVoronoiEdge2D* pedge;
} CvLCMData;


/****************************************************************************************\
*                                    Function definitions                                *
\****************************************************************************************/

#define _CV_READ_SEQ_ELEM( elem, reader, type )                       \
{                                                              \
    assert( (reader).seq->elem_size == sizeof(*elem));         \
    elem = (type)(reader).ptr;                                 \
    CV_NEXT_SEQ_ELEM( sizeof(*elem), reader )                  \
}

#define _CV_IS_SITE_REFLEX( SITE )  ((SITE) ->node[0] == (SITE) ->node[1])
#define _CV_IS_EDGE_REFLEX( EDGE )  (( (EDGE)->site[0]->node[0] == (EDGE)->site[0]->node[0] ) || \
                                      ( (EDGE)->site[1]->node[0] == (EDGE)->site[1]->node[0] ) )

#define _CV_INITIALIZE_CVLCMDATA(STRUCT,SITE,EDGE,NODE)\
{ (STRUCT)->psite = SITE ; (STRUCT)->pedge = EDGE; (STRUCT)->pnode = NODE;}
/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCM
//    Purpose: Function constructs hybrid model
//    Context:
//    Parameters:
//      LCM : in&out.
//    Returns: 1, if hybrid model was succesfully constructed
//             0, if some error occures
//F*/
CV_IMPL
int _cvConstructLCM(CvLCM* LCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMComplexNode
//    Purpose: Function constructs Complex Node (node, which consists of
//             two points and more) of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMEdge: in, input edge of hybrid model
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed node
//F*/
CV_IMPL
CvLCMNode* _cvConstructLCMComplexNode(CvLCM* pLCM,
									  CvLCMEdge* pLCMEdge,
									  CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMSimpleNode
//    Purpose: Function constructs Simple Node (node, which consists of
//             one point) of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMEdge: in, input edge of hybrid model
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed node
//F*/
CV_IMPL
CvLCMNode* _cvConstructLCMSimpleNode(CvLCM* pLCM,
									 CvLCMEdge* pLCMEdge,
									 CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMSimpleNode
//    Purpose: Function constructs Edge of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed edge
//F*/
CV_IMPL
CvLCMEdge* _cvConstructLCMEdge(CvLCM* pLCM,
							   CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvTreatExeptionalCase
//    Purpose: Function treats triangles and regular polygons
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//      pLCMInputData: in, input parameters
//    Returns: pointer to graph node
//F*/
CV_IMPL
CvLCMNode* _cvTreatExeptionalCase(CvLCM* pLCM,
								  CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvNodeMultyplicity
//    Purpose: Function seeks all non-boundary edges incident to
//              given node and correspondent incident sites
//    Context:
//    Parameters:
//      pEdge : in, original edge
//      pNode : in, given node
//      LinkedEdges : out, matrix of incident edges
//      LinkedSites : out, matrix of incident sites
//      pSite: in, original site (pNode must be the begin point of pEdge
//              for this pSite, this property hold out far all edges)
//    Returns: number of incident edges (must be less than 10)
//F*/
CV_IMPL
int _cvNodeMultyplicity(CvVoronoiSite2D* pSite,
						CvVoronoiEdge2D* pEdge,
						CvVoronoiNode2D* pNode,
						CvVoronoiEdge2D** LinkedEdges,
						CvVoronoiSite2D** LinkedSites);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMNode
//    Purpose: Function create graph node
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//    Returns: pointer to graph node
//F*/
CV_IMPL
CvLCMNode* _cvCreateLCMNode(CvLCM* pLCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMEdge
//    Purpose: Function create graph edge
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//    Returns: pointer to graph edge
//F*/
CV_IMPL
CvLCMEdge* _cvCreateLCMEdge(CvLCM* pLCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMNode
//    Purpose: Function establishs the connection between node and ege
//    Context:
//    Parameters:
//      LCMNode : in, graph node
//      LCMEdge : in, graph edge
//      LCMEdge_prev : in&out, previous edge, connected with given node
//      index: in,
//      i    : =0, if node is initial for edge
//             =1, if node  is terminal for edge
//    Returns:
//F*/
CV_IMPL
void _cvAttachLCMEdgeToLCMNode(CvLCMNode* LCMNode,
							   CvLCMEdge* LCMEdge,
							   CvLCMEdge* &LCMEdge_prev,
							   int index,
							   int i);
/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvProjectionPointToSegment
//    Purpose: Function computes the ortogonal projection of PointO to
//             to segment[PointA, PointB]
//    Context:
//    Parameters:
//      PointO, PointA,PointB: in, given points
//      PrPoint : out, projection
//      dist : distance from PointO to PrPoint
//    Returns:
//F*/
CV_IMPL
void _cvProjectionPointToSegment(CvPoint2D32f* PointO,
								 CvPoint2D32f* PointA,
								 CvPoint2D32f* PointB,
								 CvPoint2D32f* PrPoint,
								 float* dist);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvPrepareData
//    Purpose: Function fills up the struct CvLCMComplexNodeData
//    Context:
//    Parameters:
//      pLCMData : in
//      pLCMCCNData : out
//    Returns:
//F*/
CV_IMPL
void _cvPrepareData(CvLCMComplexNodeData* pLCMCCNData,
					CvLCMData* pLCMData);

/****************************************************************************************\
*                                    Function realization                               *
\****************************************************************************************/

CV_IMPL CvGraph* cvLinearContorModelFromVoronoiDiagram(CvVoronoiDiagram2D* VoronoiDiagram,
		float maxWidth) {
	CvMemStorage* LCMstorage;
	CvSet* SiteSet;
	CvLCM LCM = {NULL, VoronoiDiagram, NULL, NULL, maxWidth};

	CV_FUNCNAME( "cvLinearContorModelFromVoronoiDiagram" );
	__BEGIN__;

	if ( !VoronoiDiagram ) {
		CV_ERROR( CV_StsBadArg, "Voronoi Diagram is not defined" );
	}
	if ( maxWidth < 0 ) {
		CV_ERROR( CV_StsBadArg, "Treshold parameter must be non negative" );
	}

	for (SiteSet = VoronoiDiagram->sites;
			SiteSet != NULL;
			SiteSet = (CvSet*)SiteSet->h_next) {
		if (SiteSet->v_next) {
			CV_ERROR( CV_StsBadArg, "Can't operate with multiconnected domains" );
		}
		if (SiteSet->total > 70000) {
			CV_ERROR( CV_StsBadArg, "Can't operate with large domains" );
		}
	}


	LCMstorage = cvCreateMemStorage(0);
	LCM.EdgeStorage = cvCreateChildMemStorage(LCMstorage);
	LCM.ContourStorage = cvCreateChildMemStorage(LCMstorage);
	LCM.Graph = cvCreateGraph(CV_SEQ_KIND_GRAPH | CV_GRAPH_FLAG_ORIENTED,
							  sizeof(CvGraph),
							  sizeof(CvLCMNode),
							  sizeof(CvLCMEdge),
							  LCMstorage);
	if (!_cvConstructLCM(&LCM)) {
		cvReleaseLinearContorModelStorage(&LCM.Graph);
	}


	__END__;
	return LCM.Graph;
}//end of cvLinearContorModelFromVoronoiDiagram

CV_IMPL int cvReleaseLinearContorModelStorage(CvGraph** Graph) {
	CvSeq* LCMNodeSeq, *LCMEdgeSeq;
	CvLCMNode* pLCMNode;
	CvLCMEdge* pLCMEdge;

	/*CV_FUNCNAME( "cvReleaseLinearContorModelStorage" );*/
	__BEGIN__;

	if (!Graph || !(*Graph)) {
		return 0;
	}

	LCMNodeSeq = (CvSeq*)(*Graph);
	LCMEdgeSeq = (CvSeq*)(*Graph)->edges;
	if (LCMNodeSeq->total > 0) {
		pLCMNode = (CvLCMNode*)cvGetSeqElem(LCMNodeSeq, 0);
		if (pLCMNode->contour->storage) {
			cvReleaseMemStorage(&pLCMNode->contour->storage);
		}
	}
	if (LCMEdgeSeq->total > 0) {
		pLCMEdge = (CvLCMEdge*)cvGetSeqElem(LCMEdgeSeq, 0);
		if (pLCMEdge->chain->storage) {
			cvReleaseMemStorage(&pLCMEdge->chain->storage);
		}
	}
	if ((*Graph)->storage) {
		cvReleaseMemStorage(&(*Graph)->storage);
	}
	*Graph = NULL;


	__END__;
	return 1;
}//end of cvReleaseLinearContorModelStorage

int _cvConstructLCM(CvLCM* LCM) {
	CvVoronoiSite2D* pSite = 0;
	CvVoronoiEdge2D* pEdge = 0, *pEdge1;
	CvVoronoiNode2D* pNode, *pNode1;

	CvVoronoiEdge2D* LinkedEdges[10];
	CvVoronoiSite2D* LinkedSites[10];

	CvSeqReader reader;
	CvLCMData LCMdata;
	int i;

	for (CvSet* SiteSet = LCM->VoronoiDiagram->sites;
			SiteSet != NULL;
			SiteSet = (CvSet*)SiteSet->h_next) {
		cvStartReadSeq((CvSeq*)SiteSet, &reader);
		for (i = 0; i < SiteSet->total; i++) {
			_CV_READ_SEQ_ELEM(pSite, reader, CvVoronoiSite2D*);
			if (pSite->node[0] == pSite->node[1]) {
				continue;
			}
			pEdge = CV_LAST_VORONOIEDGE2D(pSite);
			pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite);
			if (pNode->radius > LCM->maxWidth) {
				goto PREPARECOMPLEXNODE;
			}

			pEdge1 = CV_PREV_VORONOIEDGE2D(pEdge, pSite);
			pNode1 = CV_VORONOIEDGE2D_BEGINNODE(pEdge1, pSite);
			if (pNode1->radius > LCM->maxWidth) {
				goto PREPARECOMPLEXNODE;
			}
			if (pNode1->radius == 0) {
				continue;
			}
			if (_cvNodeMultyplicity(pSite, pEdge, pNode, LinkedEdges, LinkedSites) == 1) {
				goto PREPARESIMPLENODE;
			}
		}
// treate triangle or regular polygon
		_CV_INITIALIZE_CVLCMDATA(&LCMdata, pSite, pEdge, CV_VORONOIEDGE2D_ENDNODE(pEdge, pSite));
		if (!_cvTreatExeptionalCase(LCM, &LCMdata)) {
			return 0;
		}
		continue;

PREPARECOMPLEXNODE:
		_CV_INITIALIZE_CVLCMDATA(&LCMdata, pSite, pEdge, CV_VORONOIEDGE2D_ENDNODE(pEdge, pSite));
		if (!_cvConstructLCMComplexNode(LCM, NULL, &LCMdata)) {
			return 0;
		}
		continue;

PREPARESIMPLENODE:
		_CV_INITIALIZE_CVLCMDATA(&LCMdata, pSite, pEdge, CV_VORONOIEDGE2D_ENDNODE(pEdge, pSite));
		if (!_cvConstructLCMSimpleNode(LCM, NULL, &LCMdata)) {
			return 0;
		}
		continue;
	}
	return 1;
}//end of _cvConstructLCM

CvLCMNode* _cvConstructLCMComplexNode(CvLCM* pLCM,
									  CvLCMEdge* pLCMEdge,
									  CvLCMData* pLCMInputData) {
	CvLCMNode* pLCMNode;
	CvLCMEdge* pLCMEdge_prev = NULL;
	CvSeqWriter writer;
	CvVoronoiSite2D* pSite, *pSite_first, *pSite_last;
	CvVoronoiEdge2D* pEdge, *pEdge_stop;
	CvVoronoiNode2D* pNode0, *pNode1;
	CvLCMData LCMOutputData;
	CvLCMComplexNodeData LCMCCNData;
	int index = 0;

	_cvPrepareData(&LCMCCNData, pLCMInputData);

	pLCMNode = _cvCreateLCMNode(pLCM);
	_cvAttachLCMEdgeToLCMNode(pLCMNode, pLCMEdge, pLCMEdge_prev, 1, 1);
	cvStartAppendToSeq((CvSeq*)pLCMNode->contour, &writer);
	CV_WRITE_SEQ_ELEM(LCMCCNData.site_last_pt, writer);
	index++;

	if (pLCMEdge) {
		CV_WRITE_SEQ_ELEM(LCMCCNData.edge_node.pt, writer );
		CV_WRITE_SEQ_ELEM(LCMCCNData.site_first_pt, writer );
		index += 2;
	}

	pSite_first = LCMCCNData.site_first;
	pSite_last = LCMCCNData.site_last;
	pEdge = LCMCCNData.edge;

	for (pSite = pSite_first;
			pSite != pSite_last;
			pSite = CV_NEXT_VORONOISITE2D(pSite),
			pEdge = CV_PREV_VORONOIEDGE2D(CV_LAST_VORONOIEDGE2D(pSite), pSite)) {
		pEdge_stop = CV_FIRST_VORONOIEDGE2D(pSite);
		for (; pEdge && pEdge != pEdge_stop;
				pEdge = CV_PREV_VORONOIEDGE2D(pEdge, pSite)) {
			pNode0 = CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite);
			pNode1 = CV_VORONOIEDGE2D_ENDNODE(pEdge, pSite);
			if (pNode0->radius <= pLCM->maxWidth && pNode1->radius <= pLCM->maxWidth) {
				_CV_INITIALIZE_CVLCMDATA(&LCMOutputData, pSite, pEdge, pNode1);
				_cvPrepareData(&LCMCCNData, &LCMOutputData);
				CV_WRITE_SEQ_ELEM(LCMCCNData.site_first_pt, writer);
				CV_WRITE_SEQ_ELEM(LCMCCNData.edge_node.pt, writer );
				index += 2;
				pLCMEdge = _cvConstructLCMEdge(pLCM, &LCMOutputData);
				_cvAttachLCMEdgeToLCMNode(pLCMNode, pLCMEdge, pLCMEdge_prev, index - 1, 0);
				CV_WRITE_SEQ_ELEM(LCMCCNData.site_last_pt, writer);
				index++;

				pSite = CV_TWIN_VORONOISITE2D(pSite, pEdge);
				pEdge_stop = CV_FIRST_VORONOIEDGE2D(pSite);
				if (pSite == pSite_last) {
					break;
				}
			}
		}
		if (pSite == pSite_last) {
			break;
		}

		CV_WRITE_SEQ_ELEM(pSite->node[1]->pt, writer);
		index++;
	}

	if (pLCMEdge_prev) {
		pLCMEdge_prev->next[(pLCMEdge_prev == (CvLCMEdge*)pLCMNode->first)] = pLCMNode->first;
	}
	cvEndWriteSeq(&writer);
	return pLCMNode;
}//end of _cvConstructLCMComplexNode

CvLCMNode* _cvConstructLCMSimpleNode(CvLCM* pLCM,
									 CvLCMEdge* pLCMEdge,
									 CvLCMData* pLCMInputData) {
	CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
	CvVoronoiSite2D* pSite = pLCMInputData->psite;
	CvVoronoiNode2D* pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite);

	CvVoronoiEdge2D* LinkedEdges[10];
	CvVoronoiSite2D* LinkedSites[10];
	int multyplicity = _cvNodeMultyplicity(pSite, pEdge, pNode, LinkedEdges, LinkedSites);
	if (multyplicity == 2) {
		pLCMInputData->pedge = LinkedEdges[1];
		pLCMInputData->psite = CV_TWIN_VORONOISITE2D(LinkedSites[1], LinkedEdges[1]);
		return NULL;
	}

	CvLCMEdge* pLCMEdge_prev = NULL;
	CvLCMNode* pLCMNode;
	CvLCMData LCMOutputData;

	pLCMNode = _cvCreateLCMNode(pLCM);
	cvSeqPush((CvSeq*)pLCMNode->contour, &pNode->pt);
	_cvAttachLCMEdgeToLCMNode(pLCMNode, pLCMEdge, pLCMEdge_prev, 0, 1);

	for (int i = (int)(pLCMEdge != NULL); i < multyplicity; i++) {
		pEdge = LinkedEdges[i];
		pSite = LinkedSites[i];
		_CV_INITIALIZE_CVLCMDATA(&LCMOutputData, CV_TWIN_VORONOISITE2D(pSite, pEdge), pEdge, pNode);
		pLCMEdge = _cvConstructLCMEdge(pLCM, &LCMOutputData);
		_cvAttachLCMEdgeToLCMNode(pLCMNode, pLCMEdge, pLCMEdge_prev, 0, 0);
	}
	pLCMEdge_prev->next[(pLCMEdge_prev == (CvLCMEdge*)pLCMNode->first)] = pLCMNode->first;
	return pLCMNode;
}//end of _cvConstructLCMSimpleNode

CvLCMEdge* _cvConstructLCMEdge(CvLCM* pLCM,
							   CvLCMData* pLCMInputData) {
	CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
	CvVoronoiSite2D* pSite = pLCMInputData->psite;
	float width = 0;

	CvLCMData LCMData;
	CvVoronoiNode2D* pNode0, *pNode1;

	CvLCMEdge* pLCMEdge = _cvCreateLCMEdge(pLCM);

	CvSeqWriter writer;
	cvStartAppendToSeq(pLCMEdge->chain, &writer );

	pNode0 = pNode1 = pLCMInputData->pnode;
	CV_WRITE_SEQ_ELEM(pNode0->pt, writer);
	width += pNode0->radius;

	for (int counter = 0;
			counter < pLCM->VoronoiDiagram->edges->total;
			counter++) {
		pNode1 = CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite);
		if (pNode1->radius >= pLCM->maxWidth) {
			goto CREATECOMPLEXNODE;
		}

		CV_WRITE_SEQ_ELEM(pNode1->pt, writer);
		width += pNode1->radius;
		_CV_INITIALIZE_CVLCMDATA(&LCMData, pSite, pEdge, pNode1);
		if (_cvConstructLCMSimpleNode(pLCM, pLCMEdge, &LCMData)) {
			goto LCMEDGEEXIT;
		}

		pEdge = LCMData.pedge; pSite = LCMData.psite;
		pNode0 = pNode1;
	}
	return NULL;

CREATECOMPLEXNODE:
	_CV_INITIALIZE_CVLCMDATA(&LCMData, pSite, pEdge, pNode0);
	CV_WRITE_SEQ_ELEM(LCMData.pnode->pt, writer);
	width += LCMData.pnode->radius;
	_cvConstructLCMComplexNode(pLCM, pLCMEdge, &LCMData);

LCMEDGEEXIT:
	cvEndWriteSeq(&writer);
	pLCMEdge->width = width / pLCMEdge->chain->total;
	return pLCMEdge;
}//end of _cvConstructLCMEdge

CvLCMNode* _cvTreatExeptionalCase(CvLCM* pLCM,
								  CvLCMData* pLCMInputData) {
	CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
	CvVoronoiSite2D* pSite = pLCMInputData->psite;
	CvVoronoiNode2D* pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite);
	CvLCMNode* pLCMNode = _cvCreateLCMNode(pLCM);
	cvSeqPush((CvSeq*)pLCMNode->contour, &pNode->pt);
	return pLCMNode;
}//end of _cvConstructLCMEdge

CV_INLINE
CvLCMNode* _cvCreateLCMNode(CvLCM* pLCM) {
	CvLCMNode* pLCMNode;
	cvSetAdd((CvSet*)pLCM->Graph, NULL, (CvSetElem**)&pLCMNode );
	pLCMNode->contour = (CvContour*)cvCreateSeq(0, sizeof(CvContour),
						sizeof(CvPoint2D32f), pLCM->ContourStorage);
	pLCMNode->first = NULL;
	return pLCMNode;
}//end of _cvCreateLCMNode

CV_INLINE
CvLCMEdge* _cvCreateLCMEdge(CvLCM* pLCM) {
	CvLCMEdge* pLCMEdge;
	cvSetAdd( (CvSet*)(pLCM->Graph->edges), 0, (CvSetElem**)&pLCMEdge );
	pLCMEdge->chain = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvPoint2D32f), pLCM->EdgeStorage);
	pLCMEdge->next[0] = pLCMEdge->next[1] = NULL;
	pLCMEdge->vtx[0] =  pLCMEdge->vtx[1] = NULL;
	pLCMEdge->index1 =  pLCMEdge->index2 = -1;
	return pLCMEdge;
}//end of _cvCreateLCMEdge

CV_INLINE
void _cvAttachLCMEdgeToLCMNode(CvLCMNode* LCMNode,
							   CvLCMEdge* LCMEdge,
							   CvLCMEdge* &LCMEdge_prev,
							   int index,
							   int i) {
	if (!LCMEdge) {
		return;
	}
	if (i == 0) {
		LCMEdge->index1 = index;
	} else {
		LCMEdge->index2 = index;
	}

	LCMEdge->vtx[i] = (CvGraphVtx*)LCMNode;
	if (!LCMEdge_prev) {
		LCMNode->first = (CvGraphEdge*)LCMEdge;
	} else
//      LCMEdge_prev->next[(LCMEdge_prev == (CvLCMEdge*)LCMNode->first)] = (CvGraphEdge*)LCMEdge;
	{
		LCMEdge_prev->next[(LCMEdge_prev->vtx[0] != (CvGraphVtx*)LCMNode)] = (CvGraphEdge*)LCMEdge;
	}

	LCMEdge->next[i] = LCMNode->first;
	LCMEdge_prev = LCMEdge;
}//end of _cvAttachLCMEdgeToLCMNode


int _cvNodeMultyplicity(CvVoronoiSite2D* pSite,
						CvVoronoiEdge2D* pEdge,
						CvVoronoiNode2D* pNode,
						CvVoronoiEdge2D** LinkedEdges,
						CvVoronoiSite2D** LinkedSites) {
	if (!pNode->radius) {
		return -1;
	}
	assert(pNode == CV_VORONOIEDGE2D_BEGINNODE(pEdge, pSite));

	int multyplicity = 0;
	CvVoronoiEdge2D* pEdge_cur = pEdge;
	do {
		if (pEdge_cur->node[0]->radius && pEdge_cur->node[1]->radius) {
			LinkedEdges[multyplicity] = pEdge_cur;
			LinkedSites[multyplicity] = pSite;
			multyplicity++;
		}
		pEdge_cur = CV_PREV_VORONOIEDGE2D(pEdge_cur, pSite);
		pSite = CV_TWIN_VORONOISITE2D(pSite, pEdge_cur);
	} while (pEdge_cur != pEdge);
	return multyplicity;
}//end of _cvNodeMultyplicity


CV_INLINE
void _cvPrepareData(CvLCMComplexNodeData* pLCMCCNData,
					CvLCMData* pLCMData) {
	pLCMCCNData->site_first = pLCMData->psite;
	pLCMCCNData->site_last = CV_TWIN_VORONOISITE2D(pLCMData->psite, pLCMData->pedge);
	if (pLCMData->pedge == CV_LAST_VORONOIEDGE2D(pLCMData->psite)) {
		pLCMCCNData->edge = CV_PREV_VORONOIEDGE2D(pLCMData->pedge, pLCMData->psite);
		pLCMCCNData->edge_node = *pLCMData->pnode;
		pLCMCCNData->site_first_pt = pLCMData->psite->node[0]->pt;
		pLCMCCNData->site_last_pt = pLCMData->psite->node[0]->pt;
	} else {
		pLCMCCNData->edge = pLCMData->pedge;
		pLCMCCNData->edge_node = *pLCMData->pnode;
		_cvProjectionPointToSegment(&pLCMCCNData->edge_node.pt,
									&pLCMCCNData->site_first->node[0]->pt,
									&pLCMCCNData->site_first->node[1]->pt,
									&pLCMCCNData->site_first_pt,
									NULL);
		_cvProjectionPointToSegment(&pLCMCCNData->edge_node.pt,
									&pLCMCCNData->site_last->node[0]->pt,
									&pLCMCCNData->site_last->node[1]->pt,
									&pLCMCCNData->site_last_pt,
									NULL);
	}
}//end of _cvPrepareData


void _cvProjectionPointToSegment(CvPoint2D32f* PointO,
								 CvPoint2D32f* PointA,
								 CvPoint2D32f* PointB,
								 CvPoint2D32f* PrPoint,
								 float* dist) {
	float scal_AO_AB, scal_AB_AB;
	CvPoint2D32f VectorAB = {PointB->x - PointA->x, PointB->y - PointA->y};
	scal_AB_AB = VectorAB.x * VectorAB.x + VectorAB.y * VectorAB.y;
	if (scal_AB_AB < LCM_CONST_ZERO) {
		*PrPoint = *PointA;
		if (dist) {
			*dist = (float)sqrt( (double)(PointO->x - PointA->x) * (PointO->x - PointA->x) + (PointO->y - PointA->y) * (PointO->y - PointA->y));
		}
		return;
	}

	CvPoint2D32f VectorAO = {PointO->x - PointA->x, PointO->y - PointA->y};
	scal_AO_AB = VectorAO.x * VectorAB.x + VectorAO.y * VectorAB.y;

	if (dist) {
		float vector_AO_AB = (float)fabs(VectorAO.x * VectorAB.y - VectorAO.y * VectorAB.x);
		*dist = (float)(vector_AO_AB / sqrt((double)scal_AB_AB));
	}

	float alfa = scal_AO_AB / scal_AB_AB;
	PrPoint->x = PointO->x - VectorAO.x + alfa * VectorAB.x;
	PrPoint->y = PointO->y - VectorAO.y + alfa * VectorAB.y;
	return;
}//end of _cvProjectionPointToSegment




